﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Threading;

namespace JsonRpc
{
    /// <summary>
    /// Summary description for Service01
    /// </summary>
    
    [JsonRpcObject(Namespace="Client")]
    public class TestService : JsonRpcService
    {
        public TestService()
        {
            StartCompressionAt = 1000;
        }


        [JsonRpcMethod]
        public int Sum(int a, int b)
        {
            return a + b;
        }

        [JsonRpcMethod(Name = "getMessage")]
        public string GetMessage(string name)
        {
            return "Hello " + name + "!";
        }

        [JsonRpcMethod(Name="Hello")]
        public string Hello(string name)
        {
            return "Hello " + name + "!";
        }

        [JsonRpcMethod]
        public string TestManyParams(string param1, string param2, string param3, string param4, int param5)
        {
            return "TestManyParams: " + param1 + " | " + param2 + " | " + param3 + " | " + param4 + " | " + param5.ToString();
        }

        [JsonRpcMethod(Name = "TestDate")]
        public DateTime TestDate(DateTime clientTime)
        {
            return DateTime.Now;
        }

        [JsonRpcMethod(Name = "getServerDate")]
        public DateTime GetServerDate(DateTime clientTime)
        {
            return DateTime.Now;
        }

         [JsonRpcMethod]
        public string TestCompression()
        {
            return @"
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
Response.Filter (also available from your ASPX pages) exposes a Stream which you override with a GZipStream object, this will cause the raw text response to get compressed, while telling the browser this the response is compressed with the second line Response.AppendHeader.
The reason we put this in the Global_PostReleaseRequestState event is because it allows us to target all files, not just ASPX pages.
";
        }

    }
}